package com.ourteam.product.requirement.dao;

import net.dao.BaseQueryBean;
import net.dao.BaseWhereCriterion;
import net.dao.IDataAccessInterface;

import org.apache.commons.lang.StringUtils;

import java.util.Arrays;
import java.util.List;
import java.util.Map;


/**
 * Template Name : DAO查询对象
 * Template Version : 1
 * Template Last Modfiy Date : Sat Aug 19 10:06:32 CST 2017
 * Auto Generate Date : 2018-05-03 16:45:33
  * Warning ! This file will be overwrite when regenerate !
  *
 */
public class ProductGlossaryAttrDAOQueryBean extends BaseQueryBean {
    public ProductGlossaryAttrDAOQueryBean() {
        super();
    }

    public ProductGlossaryAttrDAOQueryBean(BaseQueryBean aQueryBean) {
        super(aQueryBean);
    }

    public ProductGlossaryAttrDAOQueryBean(BaseQueryBean aQueryBean,
        Map tableReplaceMap) {
        super(aQueryBean, tableReplaceMap);
    }

    public Criteria createCriteria() {
        Criteria criteria = createCriteriaInternal();

        if (oredCriteria.size() == 0) {
            oredCriteria.add(criteria);
        }

        return criteria;
    }

    protected Criteria createCriteriaInternal() {
        return new Criteria(this);
    }

    public void addIdSelectProperty() {
        addIdSelectProperty("id");
    }

    public void addIdSelectProperty(String aAlias) {
        if (StringUtils.isNotBlank(aAlias)) {
            addSelectProperty(IProductGlossaryAttrDAO.Id, aAlias);
        } else {
            addSelectProperty(IProductGlossaryAttrDAO.Id, "id");
        }
    }

    public void addProductDefineIdSelectProperty() {
        addProductDefineIdSelectProperty("productDefineId");
    }

    public void addProductDefineIdSelectProperty(String aAlias) {
        if (StringUtils.isNotBlank(aAlias)) {
            addSelectProperty(IProductGlossaryAttrDAO.ProductDefineId, aAlias);
        } else {
            addSelectProperty(IProductGlossaryAttrDAO.ProductDefineId,
                "productDefineId");
        }
    }

    public void addProductGlossaryIdSelectProperty() {
        addProductGlossaryIdSelectProperty("productGlossaryId");
    }

    public void addProductGlossaryIdSelectProperty(String aAlias) {
        if (StringUtils.isNotBlank(aAlias)) {
            addSelectProperty(IProductGlossaryAttrDAO.ProductGlossaryId, aAlias);
        } else {
            addSelectProperty(IProductGlossaryAttrDAO.ProductGlossaryId,
                "productGlossaryId");
        }
    }

    public void addAttrNameSelectProperty() {
        addAttrNameSelectProperty("attrName");
    }

    public void addAttrNameSelectProperty(String aAlias) {
        if (StringUtils.isNotBlank(aAlias)) {
            addSelectProperty(IProductGlossaryAttrDAO.AttrName, aAlias);
        } else {
            addSelectProperty(IProductGlossaryAttrDAO.AttrName, "attrName");
        }
    }

    public void addAttrTypeSelectProperty() {
        addAttrTypeSelectProperty("attrType");
    }

    public void addAttrTypeSelectProperty(String aAlias) {
        if (StringUtils.isNotBlank(aAlias)) {
            addSelectProperty(IProductGlossaryAttrDAO.AttrType, aAlias);
        } else {
            addSelectProperty(IProductGlossaryAttrDAO.AttrType, "attrType");
        }
    }

    public void addDataRuleSelectProperty() {
        addDataRuleSelectProperty("dataRule");
    }

    public void addDataRuleSelectProperty(String aAlias) {
        if (StringUtils.isNotBlank(aAlias)) {
            addSelectProperty(IProductGlossaryAttrDAO.DataRule, aAlias);
        } else {
            addSelectProperty(IProductGlossaryAttrDAO.DataRule, "dataRule");
        }
    }

    public void addStatusSelectProperty() {
        addStatusSelectProperty("status");
    }

    public void addStatusSelectProperty(String aAlias) {
        if (StringUtils.isNotBlank(aAlias)) {
            addSelectProperty(IProductGlossaryAttrDAO.Status, aAlias);
        } else {
            addSelectProperty(IProductGlossaryAttrDAO.Status, "status");
        }
    }

    public void addRemarksSelectProperty() {
        addRemarksSelectProperty("remarks");
    }

    public void addRemarksSelectProperty(String aAlias) {
        if (StringUtils.isNotBlank(aAlias)) {
            addSelectProperty(IProductGlossaryAttrDAO.Remarks, aAlias);
        } else {
            addSelectProperty(IProductGlossaryAttrDAO.Remarks, "remarks");
        }
    }

    public void addIsRequireSelectProperty() {
        addIsRequireSelectProperty("isRequire");
    }

    public void addIsRequireSelectProperty(String aAlias) {
        if (StringUtils.isNotBlank(aAlias)) {
            addSelectProperty(IProductGlossaryAttrDAO.IsRequire, aAlias);
        } else {
            addSelectProperty(IProductGlossaryAttrDAO.IsRequire, "isRequire");
        }
    }

    public void addAllSelectProperties() {
        addIdSelectProperty();

        addProductDefineIdSelectProperty();

        addProductGlossaryIdSelectProperty();

        addAttrNameSelectProperty();

        addAttrTypeSelectProperty();

        addDataRuleSelectProperty();

        addStatusSelectProperty();

        addRemarksSelectProperty();

        addIsRequireSelectProperty();
    }

    public static class Criteria extends BaseWhereCriterion<ProductGlossaryAttrDAOQueryBean> {
        protected Criteria(ProductGlossaryAttrDAOQueryBean aParentObject) {
            super(aParentObject);
        }

        public Criteria andIdIsNull() {
            addCriterion(IProductGlossaryAttrDAO.Id + " is null");

            return this;
        }

        public Criteria andIdIsNotNull() {
            addCriterion(IProductGlossaryAttrDAO.Id + " is not null");

            return this;
        }

        public Criteria andIdIsNotEmpty() {
            addCriterion(IProductGlossaryAttrDAO.Id + " is not null AND " +
                IProductGlossaryAttrDAO.Id + " <> ''");

            return this;
        }

        public Criteria andIdIsEmpty() {
            addCriterion("(" + IProductGlossaryAttrDAO.Id + " is null OR " +
                IProductGlossaryAttrDAO.Id + " = '')");

            return this;
        }

        public Criteria andIdEqualTo(long value) {
            return andIdEqualTo(Long.valueOf(value));
        }

        public Criteria andIdEqualTo(java.lang.Long value) {
            addCriterion(IProductGlossaryAttrDAO.Id + " = ", value, "id");

            return this;
        }

        public Criteria andIdEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryAttrDAO.Id);
            str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andIdEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryAttrDAO.Id + " = ", subQueryBean, dao);

            return this;
        }

        public Criteria andIdNotEqualTo(long value) {
            return andIdNotEqualTo(Long.valueOf(value));
        }

        public Criteria andIdNotEqualTo(java.lang.Long value) {
            addCriterion(IProductGlossaryAttrDAO.Id + " <>", value, "id");

            return this;
        }

        public Criteria andIdNotEqualToOrIsNull(long value) {
            return andIdNotEqualToOrIsNull(Long.valueOf(value));
        }

        public Criteria andIdNotEqualToOrIsNull(java.lang.Long value) {
            addCriterion(IProductGlossaryAttrDAO.Id + " is null OR " +
                IProductGlossaryAttrDAO.Id + " <>", value, "id");

            return this;
        }

        public Criteria andIdNotEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryAttrDAO.Id);
            str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andIdNotEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryAttrDAO.Id + " <> ", subQueryBean, dao);

            return this;
        }

        public Criteria andIdGreaterThan(long value) {
            return andIdGreaterThan(Long.valueOf(value));
        }

        public Criteria andIdGreaterThan(java.lang.Long value) {
            addCriterion(IProductGlossaryAttrDAO.Id + " >", value, "id");

            return this;
        }

        public Criteria andIdGreaterThanForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryAttrDAO.Id);
            str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andIdGreaterThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryAttrDAO.Id + " > ", subQueryBean, dao);

            return this;
        }

        public Criteria andIdGreaterThanOrEqualTo(long value) {
            return andIdGreaterThanOrEqualTo(Long.valueOf(value));
        }

        public Criteria andIdGreaterThanOrEqualTo(java.lang.Long value) {
            addCriterion(IProductGlossaryAttrDAO.Id + " >=", value, "id");

            return this;
        }

        public Criteria andIdGreaterThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryAttrDAO.Id);
            str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andIdGreaterThanOrEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryAttrDAO.Id + " >= ", subQueryBean, dao);

            return this;
        }

        public Criteria andIdLessThan(long value) {
            return andIdLessThan(Long.valueOf(value));
        }

        public Criteria andIdLessThan(java.lang.Long value) {
            addCriterion(IProductGlossaryAttrDAO.Id + " <", value, "id");

            return this;
        }

        public Criteria andIdLessThanForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryAttrDAO.Id);
            str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andIdLessThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryAttrDAO.Id + " < ", subQueryBean, dao);

            return this;
        }

        public Criteria andIdLessThanOrEqualTo(long value) {
            return andIdLessThanOrEqualTo(Long.valueOf(value));
        }

        public Criteria andIdLessThanOrEqualTo(java.lang.Long value) {
            addCriterion(IProductGlossaryAttrDAO.Id + " <=", value, "id");

            return this;
        }

        public Criteria andIdLessThanOrEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryAttrDAO.Id);
            str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andIdLessThanOrEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryAttrDAO.Id + " <= ", subQueryBean, dao);

            return this;
        }

        public Criteria andIdIn(long[] values) {
            if (values.length == 1) {
                return andIdEqualTo((java.lang.Long) values[0]);
            } else {
                addCriterion(IProductGlossaryAttrDAO.Id + " in", values, "id");

                return this;
            }
        }

        public Criteria andIdNotIn(long[] values) {
            if (values.length == 1) {
                return andIdNotEqualTo((java.lang.Long) values[0]);
            } else {
                addCriterion(IProductGlossaryAttrDAO.Id + " not in", values,
                    "id");

                return this;
            }
        }

        public Criteria andIdIn(List<java.lang.Long> values) {
            if (values.size() == 1) {
                return andIdEqualTo(values.get(0));
            } else {
                addCriterion(IProductGlossaryAttrDAO.Id + " in", values, "id");

                return this;
            }
        }

        public Criteria andIdNotIn(List<java.lang.Long> values) {
            if (values.size() == 1) {
                return andIdNotEqualTo(values.get(0));
            } else {
                addCriterion(IProductGlossaryAttrDAO.Id + " not in", values,
                    "id");

                return this;
            }
        }

        public Criteria andIdIn(java.lang.Long[] values) {
            if (values.length == 1) {
                return andIdEqualTo(values[0]);
            } else {
                addCriterion(IProductGlossaryAttrDAO.Id + " in",
                    Arrays.asList(values), "id");

                return this;
            }
        }

        public Criteria andIdNotIn(java.lang.Long[] values) {
            if (values.length == 1) {
                return andIdNotEqualTo(values[0]);
            } else {
                addCriterion(IProductGlossaryAttrDAO.Id + " not in",
                    Arrays.asList(values), "id");

                return this;
            }
        }

        public Criteria andIdIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryAttrDAO.Id + " in ", subQueryBean, dao);

            return this;
        }

        public Criteria andIdNotIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryAttrDAO.Id + " not in ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andIdBetween(long value1, long value2) {
            addCriterion(IProductGlossaryAttrDAO.Id + " between", value1,
                value2, "id");

            return this;
        }

        public Criteria andIdBetween(java.lang.Long value1,
            java.lang.Long value2) {
            addCriterion(IProductGlossaryAttrDAO.Id + " between", value1,
                value2, "id");

            return this;
        }

        public Criteria andIdNotBetween(long value1, long value2) {
            addCriterion(IProductGlossaryAttrDAO.Id + " not between", value1,
                value2, "id");

            return this;
        }

        public Criteria andIdNotBetween(java.lang.Long value1,
            java.lang.Long value2) {
            addCriterion(IProductGlossaryAttrDAO.Id + " not between", value1,
                value2, "id");

            return this;
        }

        public Criteria andProductDefineIdIsNull() {
            addCriterion(IProductGlossaryAttrDAO.ProductDefineId + " is null");

            return this;
        }

        public Criteria andProductDefineIdIsNotNull() {
            addCriterion(IProductGlossaryAttrDAO.ProductDefineId +
                " is not null");

            return this;
        }

        public Criteria andProductDefineIdIsNotEmpty() {
            addCriterion(IProductGlossaryAttrDAO.ProductDefineId +
                " is not null AND " + IProductGlossaryAttrDAO.ProductDefineId +
                " <> ''");

            return this;
        }

        public Criteria andProductDefineIdIsEmpty() {
            addCriterion("(" + IProductGlossaryAttrDAO.ProductDefineId +
                " is null OR " + IProductGlossaryAttrDAO.ProductDefineId +
                " = '')");

            return this;
        }

        public Criteria andProductDefineIdEqualTo(long value) {
            return andProductDefineIdEqualTo(Long.valueOf(value));
        }

        public Criteria andProductDefineIdEqualTo(java.lang.Long value) {
            addCriterion(IProductGlossaryAttrDAO.ProductDefineId + " = ",
                value, "productDefineId");

            return this;
        }

        public Criteria andProductDefineIdEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryAttrDAO.ProductDefineId);
            str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductDefineIdEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryAttrDAO.ProductDefineId + " = ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andProductDefineIdNotEqualTo(long value) {
            return andProductDefineIdNotEqualTo(Long.valueOf(value));
        }

        public Criteria andProductDefineIdNotEqualTo(java.lang.Long value) {
            addCriterion(IProductGlossaryAttrDAO.ProductDefineId + " <>",
                value, "productDefineId");

            return this;
        }

        public Criteria andProductDefineIdNotEqualToOrIsNull(long value) {
            return andProductDefineIdNotEqualToOrIsNull(Long.valueOf(value));
        }

        public Criteria andProductDefineIdNotEqualToOrIsNull(
            java.lang.Long value) {
            addCriterion(IProductGlossaryAttrDAO.ProductDefineId +
                " is null OR " + IProductGlossaryAttrDAO.ProductDefineId +
                " <>", value, "productDefineId");

            return this;
        }

        public Criteria andProductDefineIdNotEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryAttrDAO.ProductDefineId);
            str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductDefineIdNotEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryAttrDAO.ProductDefineId + " <> ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andProductDefineIdGreaterThan(long value) {
            return andProductDefineIdGreaterThan(Long.valueOf(value));
        }

        public Criteria andProductDefineIdGreaterThan(java.lang.Long value) {
            addCriterion(IProductGlossaryAttrDAO.ProductDefineId + " >", value,
                "productDefineId");

            return this;
        }

        public Criteria andProductDefineIdGreaterThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryAttrDAO.ProductDefineId);
            str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductDefineIdGreaterThan(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryAttrDAO.ProductDefineId + " > ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andProductDefineIdGreaterThanOrEqualTo(long value) {
            return andProductDefineIdGreaterThanOrEqualTo(Long.valueOf(value));
        }

        public Criteria andProductDefineIdGreaterThanOrEqualTo(
            java.lang.Long value) {
            addCriterion(IProductGlossaryAttrDAO.ProductDefineId + " >=",
                value, "productDefineId");

            return this;
        }

        public Criteria andProductDefineIdGreaterThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryAttrDAO.ProductDefineId);
            str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductDefineIdGreaterThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryAttrDAO.ProductDefineId + " >= ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andProductDefineIdLessThan(long value) {
            return andProductDefineIdLessThan(Long.valueOf(value));
        }

        public Criteria andProductDefineIdLessThan(java.lang.Long value) {
            addCriterion(IProductGlossaryAttrDAO.ProductDefineId + " <", value,
                "productDefineId");

            return this;
        }

        public Criteria andProductDefineIdLessThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryAttrDAO.ProductDefineId);
            str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductDefineIdLessThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryAttrDAO.ProductDefineId + " < ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andProductDefineIdLessThanOrEqualTo(long value) {
            return andProductDefineIdLessThanOrEqualTo(Long.valueOf(value));
        }

        public Criteria andProductDefineIdLessThanOrEqualTo(
            java.lang.Long value) {
            addCriterion(IProductGlossaryAttrDAO.ProductDefineId + " <=",
                value, "productDefineId");

            return this;
        }

        public Criteria andProductDefineIdLessThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryAttrDAO.ProductDefineId);
            str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductDefineIdLessThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryAttrDAO.ProductDefineId + " <= ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andProductDefineIdIn(long[] values) {
            if (values.length == 1) {
                return andProductDefineIdEqualTo((java.lang.Long) values[0]);
            } else {
                addCriterion(IProductGlossaryAttrDAO.ProductDefineId + " in",
                    values, "productDefineId");

                return this;
            }
        }

        public Criteria andProductDefineIdNotIn(long[] values) {
            if (values.length == 1) {
                return andProductDefineIdNotEqualTo((java.lang.Long) values[0]);
            } else {
                addCriterion(IProductGlossaryAttrDAO.ProductDefineId +
                    " not in", values, "productDefineId");

                return this;
            }
        }

        public Criteria andProductDefineIdIn(List<java.lang.Long> values) {
            if (values.size() == 1) {
                return andProductDefineIdEqualTo(values.get(0));
            } else {
                addCriterion(IProductGlossaryAttrDAO.ProductDefineId + " in",
                    values, "productDefineId");

                return this;
            }
        }

        public Criteria andProductDefineIdNotIn(List<java.lang.Long> values) {
            if (values.size() == 1) {
                return andProductDefineIdNotEqualTo(values.get(0));
            } else {
                addCriterion(IProductGlossaryAttrDAO.ProductDefineId +
                    " not in", values, "productDefineId");

                return this;
            }
        }

        public Criteria andProductDefineIdIn(java.lang.Long[] values) {
            if (values.length == 1) {
                return andProductDefineIdEqualTo(values[0]);
            } else {
                addCriterion(IProductGlossaryAttrDAO.ProductDefineId + " in",
                    Arrays.asList(values), "productDefineId");

                return this;
            }
        }

        public Criteria andProductDefineIdNotIn(java.lang.Long[] values) {
            if (values.length == 1) {
                return andProductDefineIdNotEqualTo(values[0]);
            } else {
                addCriterion(IProductGlossaryAttrDAO.ProductDefineId +
                    " not in", Arrays.asList(values), "productDefineId");

                return this;
            }
        }

        public Criteria andProductDefineIdIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryAttrDAO.ProductDefineId + " in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andProductDefineIdNotIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryAttrDAO.ProductDefineId + " not in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andProductDefineIdBetween(long value1, long value2) {
            addCriterion(IProductGlossaryAttrDAO.ProductDefineId + " between",
                value1, value2, "productDefineId");

            return this;
        }

        public Criteria andProductDefineIdBetween(java.lang.Long value1,
            java.lang.Long value2) {
            addCriterion(IProductGlossaryAttrDAO.ProductDefineId + " between",
                value1, value2, "productDefineId");

            return this;
        }

        public Criteria andProductDefineIdNotBetween(long value1, long value2) {
            addCriterion(IProductGlossaryAttrDAO.ProductDefineId +
                " not between", value1, value2, "productDefineId");

            return this;
        }

        public Criteria andProductDefineIdNotBetween(java.lang.Long value1,
            java.lang.Long value2) {
            addCriterion(IProductGlossaryAttrDAO.ProductDefineId +
                " not between", value1, value2, "productDefineId");

            return this;
        }

        public Criteria andProductGlossaryIdIsNull() {
            addCriterion(IProductGlossaryAttrDAO.ProductGlossaryId +
                " is null");

            return this;
        }

        public Criteria andProductGlossaryIdIsNotNull() {
            addCriterion(IProductGlossaryAttrDAO.ProductGlossaryId +
                " is not null");

            return this;
        }

        public Criteria andProductGlossaryIdIsNotEmpty() {
            addCriterion(IProductGlossaryAttrDAO.ProductGlossaryId +
                " is not null AND " +
                IProductGlossaryAttrDAO.ProductGlossaryId + " <> ''");

            return this;
        }

        public Criteria andProductGlossaryIdIsEmpty() {
            addCriterion("(" + IProductGlossaryAttrDAO.ProductGlossaryId +
                " is null OR " + IProductGlossaryAttrDAO.ProductGlossaryId +
                " = '')");

            return this;
        }

        public Criteria andProductGlossaryIdEqualTo(long value) {
            return andProductGlossaryIdEqualTo(Long.valueOf(value));
        }

        public Criteria andProductGlossaryIdEqualTo(java.lang.Long value) {
            addCriterion(IProductGlossaryAttrDAO.ProductGlossaryId + " = ",
                value, "productGlossaryId");

            return this;
        }

        public Criteria andProductGlossaryIdEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryAttrDAO.ProductGlossaryId);
            str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductGlossaryIdEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryAttrDAO.ProductGlossaryId + " = ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andProductGlossaryIdNotEqualTo(long value) {
            return andProductGlossaryIdNotEqualTo(Long.valueOf(value));
        }

        public Criteria andProductGlossaryIdNotEqualTo(java.lang.Long value) {
            addCriterion(IProductGlossaryAttrDAO.ProductGlossaryId + " <>",
                value, "productGlossaryId");

            return this;
        }

        public Criteria andProductGlossaryIdNotEqualToOrIsNull(long value) {
            return andProductGlossaryIdNotEqualToOrIsNull(Long.valueOf(value));
        }

        public Criteria andProductGlossaryIdNotEqualToOrIsNull(
            java.lang.Long value) {
            addCriterion(IProductGlossaryAttrDAO.ProductGlossaryId +
                " is null OR " + IProductGlossaryAttrDAO.ProductGlossaryId +
                " <>", value, "productGlossaryId");

            return this;
        }

        public Criteria andProductGlossaryIdNotEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryAttrDAO.ProductGlossaryId);
            str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductGlossaryIdNotEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryAttrDAO.ProductGlossaryId + " <> ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andProductGlossaryIdGreaterThan(long value) {
            return andProductGlossaryIdGreaterThan(Long.valueOf(value));
        }

        public Criteria andProductGlossaryIdGreaterThan(java.lang.Long value) {
            addCriterion(IProductGlossaryAttrDAO.ProductGlossaryId + " >",
                value, "productGlossaryId");

            return this;
        }

        public Criteria andProductGlossaryIdGreaterThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryAttrDAO.ProductGlossaryId);
            str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductGlossaryIdGreaterThan(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryAttrDAO.ProductGlossaryId + " > ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andProductGlossaryIdGreaterThanOrEqualTo(long value) {
            return andProductGlossaryIdGreaterThanOrEqualTo(Long.valueOf(value));
        }

        public Criteria andProductGlossaryIdGreaterThanOrEqualTo(
            java.lang.Long value) {
            addCriterion(IProductGlossaryAttrDAO.ProductGlossaryId + " >=",
                value, "productGlossaryId");

            return this;
        }

        public Criteria andProductGlossaryIdGreaterThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryAttrDAO.ProductGlossaryId);
            str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductGlossaryIdGreaterThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryAttrDAO.ProductGlossaryId + " >= ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andProductGlossaryIdLessThan(long value) {
            return andProductGlossaryIdLessThan(Long.valueOf(value));
        }

        public Criteria andProductGlossaryIdLessThan(java.lang.Long value) {
            addCriterion(IProductGlossaryAttrDAO.ProductGlossaryId + " <",
                value, "productGlossaryId");

            return this;
        }

        public Criteria andProductGlossaryIdLessThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryAttrDAO.ProductGlossaryId);
            str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductGlossaryIdLessThan(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryAttrDAO.ProductGlossaryId + " < ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andProductGlossaryIdLessThanOrEqualTo(long value) {
            return andProductGlossaryIdLessThanOrEqualTo(Long.valueOf(value));
        }

        public Criteria andProductGlossaryIdLessThanOrEqualTo(
            java.lang.Long value) {
            addCriterion(IProductGlossaryAttrDAO.ProductGlossaryId + " <=",
                value, "productGlossaryId");

            return this;
        }

        public Criteria andProductGlossaryIdLessThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryAttrDAO.ProductGlossaryId);
            str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductGlossaryIdLessThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryAttrDAO.ProductGlossaryId + " <= ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andProductGlossaryIdIn(long[] values) {
            if (values.length == 1) {
                return andProductGlossaryIdEqualTo((java.lang.Long) values[0]);
            } else {
                addCriterion(IProductGlossaryAttrDAO.ProductGlossaryId + " in",
                    values, "productGlossaryId");

                return this;
            }
        }

        public Criteria andProductGlossaryIdNotIn(long[] values) {
            if (values.length == 1) {
                return andProductGlossaryIdNotEqualTo((java.lang.Long) values[0]);
            } else {
                addCriterion(IProductGlossaryAttrDAO.ProductGlossaryId +
                    " not in", values, "productGlossaryId");

                return this;
            }
        }

        public Criteria andProductGlossaryIdIn(List<java.lang.Long> values) {
            if (values.size() == 1) {
                return andProductGlossaryIdEqualTo(values.get(0));
            } else {
                addCriterion(IProductGlossaryAttrDAO.ProductGlossaryId + " in",
                    values, "productGlossaryId");

                return this;
            }
        }

        public Criteria andProductGlossaryIdNotIn(List<java.lang.Long> values) {
            if (values.size() == 1) {
                return andProductGlossaryIdNotEqualTo(values.get(0));
            } else {
                addCriterion(IProductGlossaryAttrDAO.ProductGlossaryId +
                    " not in", values, "productGlossaryId");

                return this;
            }
        }

        public Criteria andProductGlossaryIdIn(java.lang.Long[] values) {
            if (values.length == 1) {
                return andProductGlossaryIdEqualTo(values[0]);
            } else {
                addCriterion(IProductGlossaryAttrDAO.ProductGlossaryId + " in",
                    Arrays.asList(values), "productGlossaryId");

                return this;
            }
        }

        public Criteria andProductGlossaryIdNotIn(java.lang.Long[] values) {
            if (values.length == 1) {
                return andProductGlossaryIdNotEqualTo(values[0]);
            } else {
                addCriterion(IProductGlossaryAttrDAO.ProductGlossaryId +
                    " not in", Arrays.asList(values), "productGlossaryId");

                return this;
            }
        }

        public Criteria andProductGlossaryIdIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryAttrDAO.ProductGlossaryId + " in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andProductGlossaryIdNotIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryAttrDAO.ProductGlossaryId +
                " not in ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductGlossaryIdBetween(long value1, long value2) {
            addCriterion(IProductGlossaryAttrDAO.ProductGlossaryId +
                " between", value1, value2, "productGlossaryId");

            return this;
        }

        public Criteria andProductGlossaryIdBetween(java.lang.Long value1,
            java.lang.Long value2) {
            addCriterion(IProductGlossaryAttrDAO.ProductGlossaryId +
                " between", value1, value2, "productGlossaryId");

            return this;
        }

        public Criteria andProductGlossaryIdNotBetween(long value1, long value2) {
            addCriterion(IProductGlossaryAttrDAO.ProductGlossaryId +
                " not between", value1, value2, "productGlossaryId");

            return this;
        }

        public Criteria andProductGlossaryIdNotBetween(java.lang.Long value1,
            java.lang.Long value2) {
            addCriterion(IProductGlossaryAttrDAO.ProductGlossaryId +
                " not between", value1, value2, "productGlossaryId");

            return this;
        }

        public Criteria andAttrNameIsNull() {
            addCriterion(IProductGlossaryAttrDAO.AttrName + " is null");

            return this;
        }

        public Criteria andAttrNameIsNotNull() {
            addCriterion(IProductGlossaryAttrDAO.AttrName + " is not null");

            return this;
        }

        public Criteria andAttrNameIsNotEmpty() {
            addCriterion(IProductGlossaryAttrDAO.AttrName +
                " is not null AND " + IProductGlossaryAttrDAO.AttrName +
                " <> ''");

            return this;
        }

        public Criteria andAttrNameIsEmpty() {
            addCriterion("(" + IProductGlossaryAttrDAO.AttrName +
                " is null OR " + IProductGlossaryAttrDAO.AttrName + " = '')");

            return this;
        }

        public Criteria andAttrNameEqualTo(String value) {
            addCriterion(IProductGlossaryAttrDAO.AttrName + " = ", value,
                "attrName");

            return this;
        }

        public Criteria andAttrNameEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryAttrDAO.AttrName);
            str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andAttrNameEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryAttrDAO.AttrName + " = ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andAttrNameNotEqualTo(String value) {
            addCriterion(IProductGlossaryAttrDAO.AttrName + " <>", value,
                "attrName");

            return this;
        }

        public Criteria andAttrNameNotEqualToOrIsNull(String value) {
            addCriterion(IProductGlossaryAttrDAO.AttrName + " is null OR " +
                IProductGlossaryAttrDAO.AttrName + " <>", value, "attrName");

            return this;
        }

        public Criteria andAttrNameNotEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryAttrDAO.AttrName);
            str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andAttrNameNotEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryAttrDAO.AttrName + " <> ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andAttrNameGreaterThan(String value) {
            addCriterion(IProductGlossaryAttrDAO.AttrName + " >", value,
                "attrName");

            return this;
        }

        public Criteria andAttrNameGreaterThanForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryAttrDAO.AttrName);
            str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andAttrNameGreaterThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryAttrDAO.AttrName + " > ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andAttrNameGreaterThanOrEqualTo(String value) {
            addCriterion(IProductGlossaryAttrDAO.AttrName + " >=", value,
                "attrName");

            return this;
        }

        public Criteria andAttrNameGreaterThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryAttrDAO.AttrName);
            str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andAttrNameGreaterThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryAttrDAO.AttrName + " >= ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andAttrNameLessThan(String value) {
            addCriterion(IProductGlossaryAttrDAO.AttrName + " <", value,
                "attrName");

            return this;
        }

        public Criteria andAttrNameLessThanForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryAttrDAO.AttrName);
            str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andAttrNameLessThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryAttrDAO.AttrName + " < ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andAttrNameLessThanOrEqualTo(String value) {
            addCriterion(IProductGlossaryAttrDAO.AttrName + " <=", value,
                "attrName");

            return this;
        }

        public Criteria andAttrNameLessThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryAttrDAO.AttrName);
            str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andAttrNameLessThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryAttrDAO.AttrName + " <= ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andAttrNameLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductGlossaryAttrDAO.AttrName + " like",
                buffer.toString(), "attrName");

            return this;
        }

        public Criteria andAttrNameNotLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductGlossaryAttrDAO.AttrName + " not like",
                buffer.toString(), "attrName");

            return this;
        }

        public Criteria andAttrNameIn(List<String> values) {
            if (values.size() == 1) {
                return andAttrNameEqualTo(values.get(0));
            } else {
                addCriterion(IProductGlossaryAttrDAO.AttrName + " in", values,
                    "attrName");

                return this;
            }
        }

        public Criteria andAttrNameNotIn(List<String> values) {
            if (values.size() == 1) {
                return andAttrNameNotEqualTo(values.get(0));
            } else {
                addCriterion(IProductGlossaryAttrDAO.AttrName + " not in",
                    values, "attrName");

                return this;
            }
        }

        public Criteria andAttrNameIn(String[] values) {
            if (values.length == 1) {
                return andAttrNameEqualTo(values[0]);
            } else {
                addCriterion(IProductGlossaryAttrDAO.AttrName + " in",
                    Arrays.asList(values), "attrName");

                return this;
            }
        }

        public Criteria andAttrNameNotIn(String[] values) {
            if (values.length == 1) {
                return andAttrNameNotEqualTo(values[0]);
            } else {
                addCriterion(IProductGlossaryAttrDAO.AttrName + " not in",
                    Arrays.asList(values), "attrName");

                return this;
            }
        }

        public Criteria andAttrNameIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryAttrDAO.AttrName + " in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andAttrNameNotIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryAttrDAO.AttrName + " not in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andAttrNameBetween(String value1, String value2) {
            addCriterion(IProductGlossaryAttrDAO.AttrName + " between", value1,
                value2, "attrName");

            return this;
        }

        public Criteria andAttrNameNotBetween(String value1, String value2) {
            addCriterion(IProductGlossaryAttrDAO.AttrName + " not between",
                value1, value2, "attrName");

            return this;
        }

        public Criteria andAttrTypeIsNull() {
            addCriterion(IProductGlossaryAttrDAO.AttrType + " is null");

            return this;
        }

        public Criteria andAttrTypeIsNotNull() {
            addCriterion(IProductGlossaryAttrDAO.AttrType + " is not null");

            return this;
        }

        public Criteria andAttrTypeIsNotEmpty() {
            addCriterion(IProductGlossaryAttrDAO.AttrType +
                " is not null AND " + IProductGlossaryAttrDAO.AttrType +
                " <> ''");

            return this;
        }

        public Criteria andAttrTypeIsEmpty() {
            addCriterion("(" + IProductGlossaryAttrDAO.AttrType +
                " is null OR " + IProductGlossaryAttrDAO.AttrType + " = '')");

            return this;
        }

        public Criteria andAttrTypeEqualTo(String value) {
            addCriterion(IProductGlossaryAttrDAO.AttrType + " = ", value,
                "attrType");

            return this;
        }

        public Criteria andAttrTypeEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryAttrDAO.AttrType);
            str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andAttrTypeEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryAttrDAO.AttrType + " = ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andAttrTypeNotEqualTo(String value) {
            addCriterion(IProductGlossaryAttrDAO.AttrType + " <>", value,
                "attrType");

            return this;
        }

        public Criteria andAttrTypeNotEqualToOrIsNull(String value) {
            addCriterion(IProductGlossaryAttrDAO.AttrType + " is null OR " +
                IProductGlossaryAttrDAO.AttrType + " <>", value, "attrType");

            return this;
        }

        public Criteria andAttrTypeNotEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryAttrDAO.AttrType);
            str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andAttrTypeNotEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryAttrDAO.AttrType + " <> ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andAttrTypeGreaterThan(String value) {
            addCriterion(IProductGlossaryAttrDAO.AttrType + " >", value,
                "attrType");

            return this;
        }

        public Criteria andAttrTypeGreaterThanForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryAttrDAO.AttrType);
            str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andAttrTypeGreaterThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryAttrDAO.AttrType + " > ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andAttrTypeGreaterThanOrEqualTo(String value) {
            addCriterion(IProductGlossaryAttrDAO.AttrType + " >=", value,
                "attrType");

            return this;
        }

        public Criteria andAttrTypeGreaterThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryAttrDAO.AttrType);
            str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andAttrTypeGreaterThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryAttrDAO.AttrType + " >= ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andAttrTypeLessThan(String value) {
            addCriterion(IProductGlossaryAttrDAO.AttrType + " <", value,
                "attrType");

            return this;
        }

        public Criteria andAttrTypeLessThanForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryAttrDAO.AttrType);
            str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andAttrTypeLessThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryAttrDAO.AttrType + " < ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andAttrTypeLessThanOrEqualTo(String value) {
            addCriterion(IProductGlossaryAttrDAO.AttrType + " <=", value,
                "attrType");

            return this;
        }

        public Criteria andAttrTypeLessThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryAttrDAO.AttrType);
            str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andAttrTypeLessThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryAttrDAO.AttrType + " <= ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andAttrTypeLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductGlossaryAttrDAO.AttrType + " like",
                buffer.toString(), "attrType");

            return this;
        }

        public Criteria andAttrTypeNotLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductGlossaryAttrDAO.AttrType + " not like",
                buffer.toString(), "attrType");

            return this;
        }

        public Criteria andAttrTypeIn(List<String> values) {
            if (values.size() == 1) {
                return andAttrTypeEqualTo(values.get(0));
            } else {
                addCriterion(IProductGlossaryAttrDAO.AttrType + " in", values,
                    "attrType");

                return this;
            }
        }

        public Criteria andAttrTypeNotIn(List<String> values) {
            if (values.size() == 1) {
                return andAttrTypeNotEqualTo(values.get(0));
            } else {
                addCriterion(IProductGlossaryAttrDAO.AttrType + " not in",
                    values, "attrType");

                return this;
            }
        }

        public Criteria andAttrTypeIn(String[] values) {
            if (values.length == 1) {
                return andAttrTypeEqualTo(values[0]);
            } else {
                addCriterion(IProductGlossaryAttrDAO.AttrType + " in",
                    Arrays.asList(values), "attrType");

                return this;
            }
        }

        public Criteria andAttrTypeNotIn(String[] values) {
            if (values.length == 1) {
                return andAttrTypeNotEqualTo(values[0]);
            } else {
                addCriterion(IProductGlossaryAttrDAO.AttrType + " not in",
                    Arrays.asList(values), "attrType");

                return this;
            }
        }

        public Criteria andAttrTypeIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryAttrDAO.AttrType + " in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andAttrTypeNotIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryAttrDAO.AttrType + " not in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andAttrTypeBetween(String value1, String value2) {
            addCriterion(IProductGlossaryAttrDAO.AttrType + " between", value1,
                value2, "attrType");

            return this;
        }

        public Criteria andAttrTypeNotBetween(String value1, String value2) {
            addCriterion(IProductGlossaryAttrDAO.AttrType + " not between",
                value1, value2, "attrType");

            return this;
        }

        public Criteria andDataRuleIsNull() {
            addCriterion(IProductGlossaryAttrDAO.DataRule + " is null");

            return this;
        }

        public Criteria andDataRuleIsNotNull() {
            addCriterion(IProductGlossaryAttrDAO.DataRule + " is not null");

            return this;
        }

        public Criteria andDataRuleIsNotEmpty() {
            addCriterion(IProductGlossaryAttrDAO.DataRule +
                " is not null AND " + IProductGlossaryAttrDAO.DataRule +
                " <> ''");

            return this;
        }

        public Criteria andDataRuleIsEmpty() {
            addCriterion("(" + IProductGlossaryAttrDAO.DataRule +
                " is null OR " + IProductGlossaryAttrDAO.DataRule + " = '')");

            return this;
        }

        public Criteria andDataRuleEqualTo(String value) {
            addCriterion(IProductGlossaryAttrDAO.DataRule + " = ", value,
                "dataRule");

            return this;
        }

        public Criteria andDataRuleEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryAttrDAO.DataRule);
            str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andDataRuleEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryAttrDAO.DataRule + " = ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andDataRuleNotEqualTo(String value) {
            addCriterion(IProductGlossaryAttrDAO.DataRule + " <>", value,
                "dataRule");

            return this;
        }

        public Criteria andDataRuleNotEqualToOrIsNull(String value) {
            addCriterion(IProductGlossaryAttrDAO.DataRule + " is null OR " +
                IProductGlossaryAttrDAO.DataRule + " <>", value, "dataRule");

            return this;
        }

        public Criteria andDataRuleNotEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryAttrDAO.DataRule);
            str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andDataRuleNotEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryAttrDAO.DataRule + " <> ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andDataRuleGreaterThan(String value) {
            addCriterion(IProductGlossaryAttrDAO.DataRule + " >", value,
                "dataRule");

            return this;
        }

        public Criteria andDataRuleGreaterThanForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryAttrDAO.DataRule);
            str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andDataRuleGreaterThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryAttrDAO.DataRule + " > ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andDataRuleGreaterThanOrEqualTo(String value) {
            addCriterion(IProductGlossaryAttrDAO.DataRule + " >=", value,
                "dataRule");

            return this;
        }

        public Criteria andDataRuleGreaterThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryAttrDAO.DataRule);
            str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andDataRuleGreaterThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryAttrDAO.DataRule + " >= ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andDataRuleLessThan(String value) {
            addCriterion(IProductGlossaryAttrDAO.DataRule + " <", value,
                "dataRule");

            return this;
        }

        public Criteria andDataRuleLessThanForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryAttrDAO.DataRule);
            str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andDataRuleLessThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryAttrDAO.DataRule + " < ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andDataRuleLessThanOrEqualTo(String value) {
            addCriterion(IProductGlossaryAttrDAO.DataRule + " <=", value,
                "dataRule");

            return this;
        }

        public Criteria andDataRuleLessThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryAttrDAO.DataRule);
            str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andDataRuleLessThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryAttrDAO.DataRule + " <= ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andDataRuleLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductGlossaryAttrDAO.DataRule + " like",
                buffer.toString(), "dataRule");

            return this;
        }

        public Criteria andDataRuleNotLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductGlossaryAttrDAO.DataRule + " not like",
                buffer.toString(), "dataRule");

            return this;
        }

        public Criteria andDataRuleIn(List<String> values) {
            if (values.size() == 1) {
                return andDataRuleEqualTo(values.get(0));
            } else {
                addCriterion(IProductGlossaryAttrDAO.DataRule + " in", values,
                    "dataRule");

                return this;
            }
        }

        public Criteria andDataRuleNotIn(List<String> values) {
            if (values.size() == 1) {
                return andDataRuleNotEqualTo(values.get(0));
            } else {
                addCriterion(IProductGlossaryAttrDAO.DataRule + " not in",
                    values, "dataRule");

                return this;
            }
        }

        public Criteria andDataRuleIn(String[] values) {
            if (values.length == 1) {
                return andDataRuleEqualTo(values[0]);
            } else {
                addCriterion(IProductGlossaryAttrDAO.DataRule + " in",
                    Arrays.asList(values), "dataRule");

                return this;
            }
        }

        public Criteria andDataRuleNotIn(String[] values) {
            if (values.length == 1) {
                return andDataRuleNotEqualTo(values[0]);
            } else {
                addCriterion(IProductGlossaryAttrDAO.DataRule + " not in",
                    Arrays.asList(values), "dataRule");

                return this;
            }
        }

        public Criteria andDataRuleIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryAttrDAO.DataRule + " in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andDataRuleNotIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryAttrDAO.DataRule + " not in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andDataRuleBetween(String value1, String value2) {
            addCriterion(IProductGlossaryAttrDAO.DataRule + " between", value1,
                value2, "dataRule");

            return this;
        }

        public Criteria andDataRuleNotBetween(String value1, String value2) {
            addCriterion(IProductGlossaryAttrDAO.DataRule + " not between",
                value1, value2, "dataRule");

            return this;
        }

        public Criteria andStatusIsNull() {
            addCriterion(IProductGlossaryAttrDAO.Status + " is null");

            return this;
        }

        public Criteria andStatusIsNotNull() {
            addCriterion(IProductGlossaryAttrDAO.Status + " is not null");

            return this;
        }

        public Criteria andStatusIsNotEmpty() {
            addCriterion(IProductGlossaryAttrDAO.Status + " is not null AND " +
                IProductGlossaryAttrDAO.Status + " <> ''");

            return this;
        }

        public Criteria andStatusIsEmpty() {
            addCriterion("(" + IProductGlossaryAttrDAO.Status + " is null OR " +
                IProductGlossaryAttrDAO.Status + " = '')");

            return this;
        }

        public Criteria andStatusEqualTo(String value) {
            addCriterion(IProductGlossaryAttrDAO.Status + " = ", value, "status");

            return this;
        }

        public Criteria andStatusEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryAttrDAO.Status);
            str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andStatusEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryAttrDAO.Status + " = ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andStatusNotEqualTo(String value) {
            addCriterion(IProductGlossaryAttrDAO.Status + " <>", value, "status");

            return this;
        }

        public Criteria andStatusNotEqualToOrIsNull(String value) {
            addCriterion(IProductGlossaryAttrDAO.Status + " is null OR " +
                IProductGlossaryAttrDAO.Status + " <>", value, "status");

            return this;
        }

        public Criteria andStatusNotEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryAttrDAO.Status);
            str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andStatusNotEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryAttrDAO.Status + " <> ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andStatusGreaterThan(String value) {
            addCriterion(IProductGlossaryAttrDAO.Status + " >", value, "status");

            return this;
        }

        public Criteria andStatusGreaterThanForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryAttrDAO.Status);
            str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andStatusGreaterThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryAttrDAO.Status + " > ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andStatusGreaterThanOrEqualTo(String value) {
            addCriterion(IProductGlossaryAttrDAO.Status + " >=", value, "status");

            return this;
        }

        public Criteria andStatusGreaterThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryAttrDAO.Status);
            str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andStatusGreaterThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryAttrDAO.Status + " >= ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andStatusLessThan(String value) {
            addCriterion(IProductGlossaryAttrDAO.Status + " <", value, "status");

            return this;
        }

        public Criteria andStatusLessThanForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryAttrDAO.Status);
            str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andStatusLessThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryAttrDAO.Status + " < ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andStatusLessThanOrEqualTo(String value) {
            addCriterion(IProductGlossaryAttrDAO.Status + " <=", value, "status");

            return this;
        }

        public Criteria andStatusLessThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryAttrDAO.Status);
            str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andStatusLessThanOrEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryAttrDAO.Status + " <= ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andStatusLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductGlossaryAttrDAO.Status + " like",
                buffer.toString(), "status");

            return this;
        }

        public Criteria andStatusNotLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductGlossaryAttrDAO.Status + " not like",
                buffer.toString(), "status");

            return this;
        }

        public Criteria andStatusIn(List<String> values) {
            if (values.size() == 1) {
                return andStatusEqualTo(values.get(0));
            } else {
                addCriterion(IProductGlossaryAttrDAO.Status + " in", values,
                    "status");

                return this;
            }
        }

        public Criteria andStatusNotIn(List<String> values) {
            if (values.size() == 1) {
                return andStatusNotEqualTo(values.get(0));
            } else {
                addCriterion(IProductGlossaryAttrDAO.Status + " not in",
                    values, "status");

                return this;
            }
        }

        public Criteria andStatusIn(String[] values) {
            if (values.length == 1) {
                return andStatusEqualTo(values[0]);
            } else {
                addCriterion(IProductGlossaryAttrDAO.Status + " in",
                    Arrays.asList(values), "status");

                return this;
            }
        }

        public Criteria andStatusNotIn(String[] values) {
            if (values.length == 1) {
                return andStatusNotEqualTo(values[0]);
            } else {
                addCriterion(IProductGlossaryAttrDAO.Status + " not in",
                    Arrays.asList(values), "status");

                return this;
            }
        }

        public Criteria andStatusIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryAttrDAO.Status + " in ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andStatusNotIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryAttrDAO.Status + " not in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andStatusBetween(String value1, String value2) {
            addCriterion(IProductGlossaryAttrDAO.Status + " between", value1,
                value2, "status");

            return this;
        }

        public Criteria andStatusNotBetween(String value1, String value2) {
            addCriterion(IProductGlossaryAttrDAO.Status + " not between",
                value1, value2, "status");

            return this;
        }

        public Criteria andRemarksIsNull() {
            addCriterion(IProductGlossaryAttrDAO.Remarks + " is null");

            return this;
        }

        public Criteria andRemarksIsNotNull() {
            addCriterion(IProductGlossaryAttrDAO.Remarks + " is not null");

            return this;
        }

        public Criteria andRemarksIsNotEmpty() {
            addCriterion(IProductGlossaryAttrDAO.Remarks + " is not null AND " +
                IProductGlossaryAttrDAO.Remarks + " <> ''");

            return this;
        }

        public Criteria andRemarksIsEmpty() {
            addCriterion("(" + IProductGlossaryAttrDAO.Remarks +
                " is null OR " + IProductGlossaryAttrDAO.Remarks + " = '')");

            return this;
        }

        public Criteria andRemarksEqualTo(String value) {
            addCriterion(IProductGlossaryAttrDAO.Remarks + " = ", value,
                "remarks");

            return this;
        }

        public Criteria andRemarksEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryAttrDAO.Remarks);
            str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andRemarksEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryAttrDAO.Remarks + " = ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andRemarksNotEqualTo(String value) {
            addCriterion(IProductGlossaryAttrDAO.Remarks + " <>", value,
                "remarks");

            return this;
        }

        public Criteria andRemarksNotEqualToOrIsNull(String value) {
            addCriterion(IProductGlossaryAttrDAO.Remarks + " is null OR " +
                IProductGlossaryAttrDAO.Remarks + " <>", value, "remarks");

            return this;
        }

        public Criteria andRemarksNotEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryAttrDAO.Remarks);
            str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andRemarksNotEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryAttrDAO.Remarks + " <> ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andRemarksGreaterThan(String value) {
            addCriterion(IProductGlossaryAttrDAO.Remarks + " >", value,
                "remarks");

            return this;
        }

        public Criteria andRemarksGreaterThanForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryAttrDAO.Remarks);
            str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andRemarksGreaterThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryAttrDAO.Remarks + " > ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andRemarksGreaterThanOrEqualTo(String value) {
            addCriterion(IProductGlossaryAttrDAO.Remarks + " >=", value,
                "remarks");

            return this;
        }

        public Criteria andRemarksGreaterThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryAttrDAO.Remarks);
            str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andRemarksGreaterThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryAttrDAO.Remarks + " >= ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andRemarksLessThan(String value) {
            addCriterion(IProductGlossaryAttrDAO.Remarks + " <", value,
                "remarks");

            return this;
        }

        public Criteria andRemarksLessThanForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryAttrDAO.Remarks);
            str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andRemarksLessThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryAttrDAO.Remarks + " < ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andRemarksLessThanOrEqualTo(String value) {
            addCriterion(IProductGlossaryAttrDAO.Remarks + " <=", value,
                "remarks");

            return this;
        }

        public Criteria andRemarksLessThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryAttrDAO.Remarks);
            str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andRemarksLessThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryAttrDAO.Remarks + " <= ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andRemarksLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductGlossaryAttrDAO.Remarks + " like",
                buffer.toString(), "remarks");

            return this;
        }

        public Criteria andRemarksNotLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductGlossaryAttrDAO.Remarks + " not like",
                buffer.toString(), "remarks");

            return this;
        }

        public Criteria andRemarksIn(List<String> values) {
            if (values.size() == 1) {
                return andRemarksEqualTo(values.get(0));
            } else {
                addCriterion(IProductGlossaryAttrDAO.Remarks + " in", values,
                    "remarks");

                return this;
            }
        }

        public Criteria andRemarksNotIn(List<String> values) {
            if (values.size() == 1) {
                return andRemarksNotEqualTo(values.get(0));
            } else {
                addCriterion(IProductGlossaryAttrDAO.Remarks + " not in",
                    values, "remarks");

                return this;
            }
        }

        public Criteria andRemarksIn(String[] values) {
            if (values.length == 1) {
                return andRemarksEqualTo(values[0]);
            } else {
                addCriterion(IProductGlossaryAttrDAO.Remarks + " in",
                    Arrays.asList(values), "remarks");

                return this;
            }
        }

        public Criteria andRemarksNotIn(String[] values) {
            if (values.length == 1) {
                return andRemarksNotEqualTo(values[0]);
            } else {
                addCriterion(IProductGlossaryAttrDAO.Remarks + " not in",
                    Arrays.asList(values), "remarks");

                return this;
            }
        }

        public Criteria andRemarksIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryAttrDAO.Remarks + " in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andRemarksNotIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryAttrDAO.Remarks + " not in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andRemarksBetween(String value1, String value2) {
            addCriterion(IProductGlossaryAttrDAO.Remarks + " between", value1,
                value2, "remarks");

            return this;
        }

        public Criteria andRemarksNotBetween(String value1, String value2) {
            addCriterion(IProductGlossaryAttrDAO.Remarks + " not between",
                value1, value2, "remarks");

            return this;
        }

        public Criteria andIsRequireIsNull() {
            addCriterion(IProductGlossaryAttrDAO.IsRequire + " is null");

            return this;
        }

        public Criteria andIsRequireIsNotNull() {
            addCriterion(IProductGlossaryAttrDAO.IsRequire + " is not null");

            return this;
        }

        public Criteria andIsRequireIsNotEmpty() {
            addCriterion(IProductGlossaryAttrDAO.IsRequire +
                " is not null AND " + IProductGlossaryAttrDAO.IsRequire +
                " <> ''");

            return this;
        }

        public Criteria andIsRequireIsEmpty() {
            addCriterion("(" + IProductGlossaryAttrDAO.IsRequire +
                " is null OR " + IProductGlossaryAttrDAO.IsRequire + " = '')");

            return this;
        }

        public Criteria andIsRequireEqualTo(String value) {
            addCriterion(IProductGlossaryAttrDAO.IsRequire + " = ", value,
                "isRequire");

            return this;
        }

        public Criteria andIsRequireEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryAttrDAO.IsRequire);
            str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andIsRequireEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryAttrDAO.IsRequire + " = ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andIsRequireNotEqualTo(String value) {
            addCriterion(IProductGlossaryAttrDAO.IsRequire + " <>", value,
                "isRequire");

            return this;
        }

        public Criteria andIsRequireNotEqualToOrIsNull(String value) {
            addCriterion(IProductGlossaryAttrDAO.IsRequire + " is null OR " +
                IProductGlossaryAttrDAO.IsRequire + " <>", value, "isRequire");

            return this;
        }

        public Criteria andIsRequireNotEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryAttrDAO.IsRequire);
            str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andIsRequireNotEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryAttrDAO.IsRequire + " <> ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andIsRequireGreaterThan(String value) {
            addCriterion(IProductGlossaryAttrDAO.IsRequire + " >", value,
                "isRequire");

            return this;
        }

        public Criteria andIsRequireGreaterThanForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryAttrDAO.IsRequire);
            str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andIsRequireGreaterThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryAttrDAO.IsRequire + " > ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andIsRequireGreaterThanOrEqualTo(String value) {
            addCriterion(IProductGlossaryAttrDAO.IsRequire + " >=", value,
                "isRequire");

            return this;
        }

        public Criteria andIsRequireGreaterThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryAttrDAO.IsRequire);
            str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andIsRequireGreaterThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryAttrDAO.IsRequire + " >= ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andIsRequireLessThan(String value) {
            addCriterion(IProductGlossaryAttrDAO.IsRequire + " <", value,
                "isRequire");

            return this;
        }

        public Criteria andIsRequireLessThanForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryAttrDAO.IsRequire);
            str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andIsRequireLessThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryAttrDAO.IsRequire + " < ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andIsRequireLessThanOrEqualTo(String value) {
            addCriterion(IProductGlossaryAttrDAO.IsRequire + " <=", value,
                "isRequire");

            return this;
        }

        public Criteria andIsRequireLessThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductGlossaryAttrDAO.IsRequire);
            str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andIsRequireLessThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryAttrDAO.IsRequire + " <= ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andIsRequireLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductGlossaryAttrDAO.IsRequire + " like",
                buffer.toString(), "isRequire");

            return this;
        }

        public Criteria andIsRequireNotLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductGlossaryAttrDAO.IsRequire + " not like",
                buffer.toString(), "isRequire");

            return this;
        }

        public Criteria andIsRequireIn(List<String> values) {
            if (values.size() == 1) {
                return andIsRequireEqualTo(values.get(0));
            } else {
                addCriterion(IProductGlossaryAttrDAO.IsRequire + " in", values,
                    "isRequire");

                return this;
            }
        }

        public Criteria andIsRequireNotIn(List<String> values) {
            if (values.size() == 1) {
                return andIsRequireNotEqualTo(values.get(0));
            } else {
                addCriterion(IProductGlossaryAttrDAO.IsRequire + " not in",
                    values, "isRequire");

                return this;
            }
        }

        public Criteria andIsRequireIn(String[] values) {
            if (values.length == 1) {
                return andIsRequireEqualTo(values[0]);
            } else {
                addCriterion(IProductGlossaryAttrDAO.IsRequire + " in",
                    Arrays.asList(values), "isRequire");

                return this;
            }
        }

        public Criteria andIsRequireNotIn(String[] values) {
            if (values.length == 1) {
                return andIsRequireNotEqualTo(values[0]);
            } else {
                addCriterion(IProductGlossaryAttrDAO.IsRequire + " not in",
                    Arrays.asList(values), "isRequire");

                return this;
            }
        }

        public Criteria andIsRequireIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryAttrDAO.IsRequire + " in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andIsRequireNotIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductGlossaryAttrDAO.IsRequire + " not in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andIsRequireBetween(String value1, String value2) {
            addCriterion(IProductGlossaryAttrDAO.IsRequire + " between",
                value1, value2, "isRequire");

            return this;
        }

        public Criteria andIsRequireNotBetween(String value1, String value2) {
            addCriterion(IProductGlossaryAttrDAO.IsRequire + " not between",
                value1, value2, "isRequire");

            return this;
        }
    }
}
